// Generated from C:\Users\N42\workspace\mgr\grammar\AlloyANTLR4Grammar.g4 by ANTLR 4.1
package pl.edu.pw.elka.dzielins.revanalyzer.alloy.io.grammar;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class AlloyANTLR4GrammarParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		NAME=1, NUMBER=2, COMMA=3, PLUS=4, EQUALS=5, MINUS=6, PERIOD=7, COLON=8, 
		SLASH=9, LSQRBRACKET=10, RSQRBRACKET=11, LCRLBRACKET=12, RCRLBRACKET=13, 
		LPARENTHESIS=14, RPARENTHESIS=15, AT=16, ET=17, EXCLAMATION=18, HASH=19, 
		TILDE=20, ASTERIX=21, CARET=22, BAR=23, EXACTLY_KEYWORD=24, MODULE_KEYWORD=25, 
		THIS_KEYWORD=26, PRIVATE_KEYWORD=27, OPEN_KEYWORD=28, AS_KEYWORD=29, UNIV_KEYWORD=30, 
		INT_KEYWORD=31, SEQINT_KEYWORD=32, SEQ_KEYWORD=33, FACT_KEYWORD=34, ASSERT_KEYWORD=35, 
		FUN_KEYWORD=36, PRED_KEYWORD=37, RUN_KEYWORD=38, CHECK_KEYWORD=39, FOR_KEYWORD=40, 
		BUT_KEYWORD=41, SIG_KEYWORD=42, ENUM_KEYWORD=43, ABSTRACT_KEYWORD=44, 
		LONE_KEYWORD=45, ONE_KEYWORD=46, SOME_KEYWORD=47, EXTENDS_KEYWORD=48, 
		IN_KEYWORD=49, NONE_KEYWORD=50, IDEN_KEYWORD=51, IMPLICATION_KEYWORD=52, 
		ELSE_KEYWORD=53, NOT_KEYWORD=54, LET_KEYWORD=55, DISJ_KEYWORD=56, ALL_KEYWORD=57, 
		NO_KEYWORD=58, SET_KEYWORD=59, SUM_KEYWORD=60, AND_KEYWORD=61, CONJUNCTION_KEYWORD=62, 
		OR_KEYWORD=63, DISJUNCTION_KEYWORD=64, IFF_KEYWORD=65, BI_IMPLIC_KEYWORD=66, 
		OVERRIDE_KEYWORD=67, RESTRICTION_KEYWORD=68, R2_ARROWS_KEYWORD=69, R3_ARROWS_KEYWORD=70, 
		L2_ARROWS_KEYWORD=71, RARROW_KEYWORD=72, GT_KEYWORD=73, GET_KEYWORD=74, 
		LT_KEYWORD=75, ELT_KEYWORD=76;
	public static final String[] tokenNames = {
		"<INVALID>", "NAME", "NUMBER", "','", "'+'", "'='", "'-'", "'.'", "':'", 
		"'/'", "'['", "']'", "'{'", "'}'", "'('", "')'", "'@'", "'&'", "'!'", 
		"'#'", "'~'", "'*'", "'^'", "'|'", "'exactly'", "'module'", "'this'", 
		"'private'", "'open'", "'as'", "'univ'", "'Int'", "'seq/Int'", "'seq'", 
		"'fact'", "'assert'", "'fun'", "'pred'", "'run'", "'check'", "'for'", 
		"'but'", "'sig'", "'enum'", "'abstract'", "'lone'", "'one'", "'some'", 
		"'extends'", "'in'", "'none'", "'iden'", "IMPLICATION_KEYWORD", "'else'", 
		"NOT_KEYWORD", "'let'", "'disj'", "'all'", "'no'", "'set'", "'sum'", "'and'", 
		"'&&'", "'or'", "'||'", "'iff'", "'<=>'", "'++'", "RESTRICTION_KEYWORD", 
		"'>>'", "'>>>'", "'<<'", "'->'", "'>'", "'>='", "'<'", "'=<'"
	};
	public static final int
		RULE_specification = 0, RULE_module = 1, RULE_open = 2, RULE_paragraph = 3, 
		RULE_factDecl = 4, RULE_assertDecl = 5, RULE_funDecl = 6, RULE_cmdDecl = 7, 
		RULE_scope = 8, RULE_typescope = 9, RULE_sigDecl = 10, RULE_enumDecl = 11, 
		RULE_sigQual = 12, RULE_sigExt = 13, RULE_exprH = 14, RULE_exprT = 15, 
		RULE_decl = 16, RULE_letDecl = 17, RULE_quant = 18, RULE_binOp = 19, RULE_arrowOp = 20, 
		RULE_compareOp = 21, RULE_unOp = 22, RULE_block = 23, RULE_blockOrBar = 24, 
		RULE_name = 25, RULE_ref = 26;
	public static final String[] ruleNames = {
		"specification", "module", "open", "paragraph", "factDecl", "assertDecl", 
		"funDecl", "cmdDecl", "scope", "typescope", "sigDecl", "enumDecl", "sigQual", 
		"sigExt", "exprH", "exprT", "decl", "letDecl", "quant", "binOp", "arrowOp", 
		"compareOp", "unOp", "block", "blockOrBar", "name", "ref"
	};

	@Override
	public String getGrammarFileName() { return "AlloyANTLR4Grammar.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public ATN getATN() { return _ATN; }

	public AlloyANTLR4GrammarParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class SpecificationContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(AlloyANTLR4GrammarParser.EOF, 0); }
		public OpenContext open(int i) {
			return getRuleContext(OpenContext.class,i);
		}
		public List<OpenContext> open() {
			return getRuleContexts(OpenContext.class);
		}
		public List<ParagraphContext> paragraph() {
			return getRuleContexts(ParagraphContext.class);
		}
		public ModuleContext module() {
			return getRuleContext(ModuleContext.class,0);
		}
		public ParagraphContext paragraph(int i) {
			return getRuleContext(ParagraphContext.class,i);
		}
		public SpecificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_specification; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterSpecification(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitSpecification(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitSpecification(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SpecificationContext specification() throws RecognitionException {
		SpecificationContext _localctx = new SpecificationContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_specification);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(55);
			_la = _input.LA(1);
			if (_la==MODULE_KEYWORD) {
				{
				setState(54); module();
				}
			}

			setState(60);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(57); open();
					}
					} 
				}
				setState(62);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
			}
			setState(66);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << LCRLBRACKET) | (1L << THIS_KEYWORD) | (1L << PRIVATE_KEYWORD) | (1L << FACT_KEYWORD) | (1L << ASSERT_KEYWORD) | (1L << FUN_KEYWORD) | (1L << PRED_KEYWORD) | (1L << RUN_KEYWORD) | (1L << CHECK_KEYWORD) | (1L << FOR_KEYWORD) | (1L << SIG_KEYWORD) | (1L << ENUM_KEYWORD) | (1L << ABSTRACT_KEYWORD) | (1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD))) != 0)) {
				{
				{
				setState(63); paragraph();
				}
				}
				setState(68);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(69); match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ModuleContext extends ParserRuleContext {
		public TerminalNode RSQRBRACKET() { return getToken(AlloyANTLR4GrammarParser.RSQRBRACKET, 0); }
		public TerminalNode LSQRBRACKET() { return getToken(AlloyANTLR4GrammarParser.LSQRBRACKET, 0); }
		public List<TerminalNode> EXACTLY_KEYWORD() { return getTokens(AlloyANTLR4GrammarParser.EXACTLY_KEYWORD); }
		public TerminalNode MODULE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.MODULE_KEYWORD, 0); }
		public List<TerminalNode> COMMA() { return getTokens(AlloyANTLR4GrammarParser.COMMA); }
		public TerminalNode EXACTLY_KEYWORD(int i) {
			return getToken(AlloyANTLR4GrammarParser.EXACTLY_KEYWORD, i);
		}
		public NameContext name(int i) {
			return getRuleContext(NameContext.class,i);
		}
		public TerminalNode COMMA(int i) {
			return getToken(AlloyANTLR4GrammarParser.COMMA, i);
		}
		public List<NameContext> name() {
			return getRuleContexts(NameContext.class);
		}
		public ModuleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_module; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterModule(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitModule(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitModule(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ModuleContext module() throws RecognitionException {
		ModuleContext _localctx = new ModuleContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_module);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(71); match(MODULE_KEYWORD);
			setState(72); name();
			setState(90);
			_la = _input.LA(1);
			if (_la==LSQRBRACKET) {
				{
				setState(73); match(LSQRBRACKET);
				setState(75);
				_la = _input.LA(1);
				if (_la==EXACTLY_KEYWORD) {
					{
					setState(74); match(EXACTLY_KEYWORD);
					}
				}

				setState(77); name();
				setState(85);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(78); match(COMMA);
					setState(80);
					_la = _input.LA(1);
					if (_la==EXACTLY_KEYWORD) {
						{
						setState(79); match(EXACTLY_KEYWORD);
						}
					}

					setState(82); name();
					}
					}
					setState(87);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(88); match(RSQRBRACKET);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OpenContext extends ParserRuleContext {
		public TerminalNode AS_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.AS_KEYWORD, 0); }
		public TerminalNode RSQRBRACKET() { return getToken(AlloyANTLR4GrammarParser.RSQRBRACKET, 0); }
		public TerminalNode LSQRBRACKET() { return getToken(AlloyANTLR4GrammarParser.LSQRBRACKET, 0); }
		public List<RefContext> ref() {
			return getRuleContexts(RefContext.class);
		}
		public RefContext ref(int i) {
			return getRuleContext(RefContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(AlloyANTLR4GrammarParser.COMMA); }
		public NameContext name(int i) {
			return getRuleContext(NameContext.class,i);
		}
		public TerminalNode OPEN_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.OPEN_KEYWORD, 0); }
		public TerminalNode COMMA(int i) {
			return getToken(AlloyANTLR4GrammarParser.COMMA, i);
		}
		public TerminalNode PRIVATE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.PRIVATE_KEYWORD, 0); }
		public List<NameContext> name() {
			return getRuleContexts(NameContext.class);
		}
		public OpenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_open; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterOpen(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitOpen(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitOpen(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OpenContext open() throws RecognitionException {
		OpenContext _localctx = new OpenContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_open);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(93);
			_la = _input.LA(1);
			if (_la==PRIVATE_KEYWORD) {
				{
				setState(92); match(PRIVATE_KEYWORD);
				}
			}

			setState(95); match(OPEN_KEYWORD);
			setState(96); name();
			setState(108);
			_la = _input.LA(1);
			if (_la==LSQRBRACKET) {
				{
				setState(97); match(LSQRBRACKET);
				setState(98); ref();
				setState(103);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(99); match(COMMA);
					setState(100); ref();
					}
					}
					setState(105);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(106); match(RSQRBRACKET);
				}
			}

			setState(110); match(AS_KEYWORD);
			setState(111); name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParagraphContext extends ParserRuleContext {
		public SigDeclContext sigDecl() {
			return getRuleContext(SigDeclContext.class,0);
		}
		public FactDeclContext factDecl() {
			return getRuleContext(FactDeclContext.class,0);
		}
		public EnumDeclContext enumDecl() {
			return getRuleContext(EnumDeclContext.class,0);
		}
		public FunDeclContext funDecl() {
			return getRuleContext(FunDeclContext.class,0);
		}
		public AssertDeclContext assertDecl() {
			return getRuleContext(AssertDeclContext.class,0);
		}
		public CmdDeclContext cmdDecl() {
			return getRuleContext(CmdDeclContext.class,0);
		}
		public ParagraphContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paragraph; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterParagraph(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitParagraph(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitParagraph(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParagraphContext paragraph() throws RecognitionException {
		ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_paragraph);
		try {
			setState(119);
			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(113); factDecl();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(114); assertDecl();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(115); funDecl();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(116); cmdDecl();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(117); enumDecl();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(118); sigDecl();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FactDeclContext extends ParserRuleContext {
		public TerminalNode FACT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.FACT_KEYWORD, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public FactDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_factDecl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterFactDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitFactDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitFactDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FactDeclContext factDecl() throws RecognitionException {
		FactDeclContext _localctx = new FactDeclContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_factDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(121); match(FACT_KEYWORD);
			setState(123);
			_la = _input.LA(1);
			if (_la==NAME || _la==THIS_KEYWORD) {
				{
				setState(122); name();
				}
			}

			setState(125); block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AssertDeclContext extends ParserRuleContext {
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode ASSERT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ASSERT_KEYWORD, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public AssertDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assertDecl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterAssertDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitAssertDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitAssertDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AssertDeclContext assertDecl() throws RecognitionException {
		AssertDeclContext _localctx = new AssertDeclContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_assertDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(127); match(ASSERT_KEYWORD);
			setState(129);
			_la = _input.LA(1);
			if (_la==NAME || _la==THIS_KEYWORD) {
				{
				setState(128); name();
				}
			}

			setState(131); block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FunDeclContext extends ParserRuleContext {
		public TerminalNode LSQRBRACKET() { return getToken(AlloyANTLR4GrammarParser.LSQRBRACKET, 0); }
		public TerminalNode RSQRBRACKET() { return getToken(AlloyANTLR4GrammarParser.RSQRBRACKET, 0); }
		public List<DeclContext> decl() {
			return getRuleContexts(DeclContext.class);
		}
		public TerminalNode PRED_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.PRED_KEYWORD, 0); }
		public DeclContext decl(int i) {
			return getRuleContext(DeclContext.class,i);
		}
		public TerminalNode RPARENTHESIS() { return getToken(AlloyANTLR4GrammarParser.RPARENTHESIS, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public RefContext ref() {
			return getRuleContext(RefContext.class,0);
		}
		public TerminalNode FUN_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.FUN_KEYWORD, 0); }
		public TerminalNode LPARENTHESIS() { return getToken(AlloyANTLR4GrammarParser.LPARENTHESIS, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public ExprHContext exprH() {
			return getRuleContext(ExprHContext.class,0);
		}
		public TerminalNode COLON() { return getToken(AlloyANTLR4GrammarParser.COLON, 0); }
		public TerminalNode PRIVATE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.PRIVATE_KEYWORD, 0); }
		public TerminalNode PERIOD() { return getToken(AlloyANTLR4GrammarParser.PERIOD, 0); }
		public FunDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_funDecl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterFunDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitFunDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitFunDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FunDeclContext funDecl() throws RecognitionException {
		FunDeclContext _localctx = new FunDeclContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_funDecl);
		int _la;
		try {
			setState(198);
			switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(134);
				_la = _input.LA(1);
				if (_la==PRIVATE_KEYWORD) {
					{
					setState(133); match(PRIVATE_KEYWORD);
					}
				}

				setState(136); match(FUN_KEYWORD);
				setState(140);
				switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
				case 1:
					{
					setState(137); ref();
					setState(138); match(PERIOD);
					}
					break;
				}
				setState(142); name();
				setState(161);
				switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
				case 1:
					{
					{
					setState(143); match(LPARENTHESIS);
					setState(147);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << THIS_KEYWORD) | (1L << PRIVATE_KEYWORD) | (1L << DISJ_KEYWORD))) != 0)) {
						{
						{
						setState(144); decl();
						}
						}
						setState(149);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(150); match(RPARENTHESIS);
					setState(151); match(COLON);
					}
					}
					break;

				case 2:
					{
					{
					setState(152); match(LSQRBRACKET);
					setState(156);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << THIS_KEYWORD) | (1L << PRIVATE_KEYWORD) | (1L << DISJ_KEYWORD))) != 0)) {
						{
						{
						setState(153); decl();
						}
						}
						setState(158);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(159); match(RSQRBRACKET);
					setState(160); match(COLON);
					}
					}
					break;
				}
				setState(163); exprH();
				setState(164); block();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(167);
				_la = _input.LA(1);
				if (_la==PRIVATE_KEYWORD) {
					{
					setState(166); match(PRIVATE_KEYWORD);
					}
				}

				setState(169); match(PRED_KEYWORD);
				setState(173);
				switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
				case 1:
					{
					setState(170); ref();
					setState(171); match(PERIOD);
					}
					break;
				}
				setState(175); name();
				setState(194);
				switch (_input.LA(1)) {
				case LPARENTHESIS:
					{
					{
					setState(176); match(LPARENTHESIS);
					setState(180);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << THIS_KEYWORD) | (1L << PRIVATE_KEYWORD) | (1L << DISJ_KEYWORD))) != 0)) {
						{
						{
						setState(177); decl();
						}
						}
						setState(182);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(183); match(RPARENTHESIS);
					setState(184); match(COLON);
					}
					}
					break;
				case LSQRBRACKET:
					{
					{
					setState(185); match(LSQRBRACKET);
					setState(189);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << THIS_KEYWORD) | (1L << PRIVATE_KEYWORD) | (1L << DISJ_KEYWORD))) != 0)) {
						{
						{
						setState(186); decl();
						}
						}
						setState(191);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(192); match(RSQRBRACKET);
					setState(193); match(COLON);
					}
					}
					break;
				case LCRLBRACKET:
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(196); block();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CmdDeclContext extends ParserRuleContext {
		public ScopeContext scope() {
			return getRuleContext(ScopeContext.class,0);
		}
		public NameContext name(int i) {
			return getRuleContext(NameContext.class,i);
		}
		public TerminalNode CHECK_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.CHECK_KEYWORD, 0); }
		public TerminalNode RUN_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.RUN_KEYWORD, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode COLON() { return getToken(AlloyANTLR4GrammarParser.COLON, 0); }
		public List<NameContext> name() {
			return getRuleContexts(NameContext.class);
		}
		public CmdDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cmdDecl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterCmdDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitCmdDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitCmdDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CmdDeclContext cmdDecl() throws RecognitionException {
		CmdDeclContext _localctx = new CmdDeclContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_cmdDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(203);
			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
			case 1:
				{
				setState(200); name();
				setState(201); match(COLON);
				}
				break;
			}
			setState(206);
			_la = _input.LA(1);
			if (_la==RUN_KEYWORD || _la==CHECK_KEYWORD) {
				{
				setState(205);
				_la = _input.LA(1);
				if ( !(_la==RUN_KEYWORD || _la==CHECK_KEYWORD) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				}
			}

			setState(210);
			switch (_input.LA(1)) {
			case NAME:
			case THIS_KEYWORD:
				{
				setState(208); name();
				}
				break;
			case LCRLBRACKET:
				{
				setState(209); block();
				}
				break;
			case FOR_KEYWORD:
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(212); scope();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ScopeContext extends ParserRuleContext {
		public TypescopeContext typescope(int i) {
			return getRuleContext(TypescopeContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(AlloyANTLR4GrammarParser.COMMA); }
		public List<TypescopeContext> typescope() {
			return getRuleContexts(TypescopeContext.class);
		}
		public TerminalNode NUMBER() { return getToken(AlloyANTLR4GrammarParser.NUMBER, 0); }
		public TerminalNode COMMA(int i) {
			return getToken(AlloyANTLR4GrammarParser.COMMA, i);
		}
		public TerminalNode BUT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.BUT_KEYWORD, 0); }
		public TerminalNode FOR_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.FOR_KEYWORD, 0); }
		public ScopeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_scope; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterScope(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitScope(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitScope(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ScopeContext scope() throws RecognitionException {
		ScopeContext _localctx = new ScopeContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_scope);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(214); match(FOR_KEYWORD);
			setState(235);
			switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
			case 1:
				{
				{
				setState(215); match(NUMBER);
				setState(225);
				_la = _input.LA(1);
				if (_la==BUT_KEYWORD) {
					{
					setState(216); match(BUT_KEYWORD);
					setState(217); typescope();
					setState(222);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(218); match(COMMA);
						setState(219); typescope();
						}
						}
						setState(224);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
				}

				}
				}
				break;

			case 2:
				{
				{
				setState(227); typescope();
				setState(232);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(228); match(COMMA);
					setState(229); typescope();
					}
					}
					setState(234);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TypescopeContext extends ParserRuleContext {
		public TerminalNode EXACTLY_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.EXACTLY_KEYWORD, 0); }
		public TerminalNode SEQINT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SEQINT_KEYWORD, 0); }
		public TerminalNode INT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.INT_KEYWORD, 0); }
		public TerminalNode NUMBER() { return getToken(AlloyANTLR4GrammarParser.NUMBER, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public TypescopeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typescope; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterTypescope(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitTypescope(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitTypescope(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypescopeContext typescope() throws RecognitionException {
		TypescopeContext _localctx = new TypescopeContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_typescope);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(238);
			_la = _input.LA(1);
			if (_la==EXACTLY_KEYWORD) {
				{
				setState(237); match(EXACTLY_KEYWORD);
				}
			}

			setState(240); match(NUMBER);
			setState(243);
			switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
			case 1:
				{
				setState(241); name();
				}
				break;

			case 2:
				{
				setState(242);
				_la = _input.LA(1);
				if ( !(_la==INT_KEYWORD || _la==SEQINT_KEYWORD) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SigDeclContext extends ParserRuleContext {
		public SigQualContext sigQual(int i) {
			return getRuleContext(SigQualContext.class,i);
		}
		public TerminalNode LCRLBRACKET() { return getToken(AlloyANTLR4GrammarParser.LCRLBRACKET, 0); }
		public TerminalNode RCRLBRACKET() { return getToken(AlloyANTLR4GrammarParser.RCRLBRACKET, 0); }
		public List<TerminalNode> COMMA() { return getTokens(AlloyANTLR4GrammarParser.COMMA); }
		public SigExtContext sigExt() {
			return getRuleContext(SigExtContext.class,0);
		}
		public TerminalNode SIG_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SIG_KEYWORD, 0); }
		public List<DeclContext> decl() {
			return getRuleContexts(DeclContext.class);
		}
		public NameContext name(int i) {
			return getRuleContext(NameContext.class,i);
		}
		public List<SigQualContext> sigQual() {
			return getRuleContexts(SigQualContext.class);
		}
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public DeclContext decl(int i) {
			return getRuleContext(DeclContext.class,i);
		}
		public TerminalNode COMMA(int i) {
			return getToken(AlloyANTLR4GrammarParser.COMMA, i);
		}
		public List<NameContext> name() {
			return getRuleContexts(NameContext.class);
		}
		public SigDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sigDecl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterSigDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitSigDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitSigDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SigDeclContext sigDecl() throws RecognitionException {
		SigDeclContext _localctx = new SigDeclContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_sigDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(248);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRIVATE_KEYWORD) | (1L << ABSTRACT_KEYWORD) | (1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD))) != 0)) {
				{
				{
				setState(245); sigQual();
				}
				}
				setState(250);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(251); match(SIG_KEYWORD);
			setState(252); name();
			setState(257);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(253); match(COMMA);
				setState(254); name();
				}
				}
				setState(259);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(261);
			_la = _input.LA(1);
			if (_la==EXTENDS_KEYWORD || _la==IN_KEYWORD) {
				{
				setState(260); sigExt();
				}
			}

			setState(263); match(LCRLBRACKET);
			setState(267);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << THIS_KEYWORD) | (1L << PRIVATE_KEYWORD) | (1L << DISJ_KEYWORD))) != 0)) {
				{
				{
				setState(264); decl();
				}
				}
				setState(269);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(270); match(RCRLBRACKET);
			setState(272);
			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
			case 1:
				{
				setState(271); block();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EnumDeclContext extends ParserRuleContext {
		public TerminalNode LCRLBRACKET() { return getToken(AlloyANTLR4GrammarParser.LCRLBRACKET, 0); }
		public TerminalNode ENUM_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ENUM_KEYWORD, 0); }
		public TerminalNode RCRLBRACKET() { return getToken(AlloyANTLR4GrammarParser.RCRLBRACKET, 0); }
		public List<TerminalNode> COMMA() { return getTokens(AlloyANTLR4GrammarParser.COMMA); }
		public NameContext name(int i) {
			return getRuleContext(NameContext.class,i);
		}
		public TerminalNode COMMA(int i) {
			return getToken(AlloyANTLR4GrammarParser.COMMA, i);
		}
		public List<NameContext> name() {
			return getRuleContexts(NameContext.class);
		}
		public EnumDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumDecl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterEnumDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitEnumDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitEnumDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumDeclContext enumDecl() throws RecognitionException {
		EnumDeclContext _localctx = new EnumDeclContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_enumDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(274); match(ENUM_KEYWORD);
			setState(275); name();
			setState(276); match(LCRLBRACKET);
			setState(277); name();
			setState(282);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(278); match(COMMA);
				setState(279); name();
				}
				}
				setState(284);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(285); match(RCRLBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SigQualContext extends ParserRuleContext {
		public TerminalNode SOME_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SOME_KEYWORD, 0); }
		public TerminalNode LONE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.LONE_KEYWORD, 0); }
		public TerminalNode ONE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ONE_KEYWORD, 0); }
		public TerminalNode PRIVATE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.PRIVATE_KEYWORD, 0); }
		public TerminalNode ABSTRACT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ABSTRACT_KEYWORD, 0); }
		public SigQualContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sigQual; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterSigQual(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitSigQual(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitSigQual(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SigQualContext sigQual() throws RecognitionException {
		SigQualContext _localctx = new SigQualContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_sigQual);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(287);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRIVATE_KEYWORD) | (1L << ABSTRACT_KEYWORD) | (1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SigExtContext extends ParserRuleContext {
		public List<RefContext> ref() {
			return getRuleContexts(RefContext.class);
		}
		public RefContext ref(int i) {
			return getRuleContext(RefContext.class,i);
		}
		public List<TerminalNode> PLUS() { return getTokens(AlloyANTLR4GrammarParser.PLUS); }
		public TerminalNode IN_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.IN_KEYWORD, 0); }
		public TerminalNode EXTENDS_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.EXTENDS_KEYWORD, 0); }
		public TerminalNode PLUS(int i) {
			return getToken(AlloyANTLR4GrammarParser.PLUS, i);
		}
		public SigExtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sigExt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterSigExt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitSigExt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitSigExt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SigExtContext sigExt() throws RecognitionException {
		SigExtContext _localctx = new SigExtContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_sigExt);
		int _la;
		try {
			setState(300);
			switch (_input.LA(1)) {
			case EXTENDS_KEYWORD:
				enterOuterAlt(_localctx, 1);
				{
				setState(289); match(EXTENDS_KEYWORD);
				setState(290); ref();
				}
				break;
			case IN_KEYWORD:
				enterOuterAlt(_localctx, 2);
				{
				setState(291); match(IN_KEYWORD);
				setState(292); ref();
				setState(297);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==PLUS) {
					{
					{
					setState(293); match(PLUS);
					setState(294); ref();
					}
					}
					setState(299);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExprHContext extends ParserRuleContext {
		public UnOpContext unOp() {
			return getRuleContext(UnOpContext.class,0);
		}
		public BlockOrBarContext blockOrBar() {
			return getRuleContext(BlockOrBarContext.class,0);
		}
		public TerminalNode UNIV_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.UNIV_KEYWORD, 0); }
		public TerminalNode SEQINT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SEQINT_KEYWORD, 0); }
		public List<DeclContext> decl() {
			return getRuleContexts(DeclContext.class);
		}
		public DeclContext decl(int i) {
			return getRuleContext(DeclContext.class,i);
		}
		public LetDeclContext letDecl(int i) {
			return getRuleContext(LetDeclContext.class,i);
		}
		public TerminalNode LCRLBRACKET() { return getToken(AlloyANTLR4GrammarParser.LCRLBRACKET, 0); }
		public TerminalNode LPARENTHESIS() { return getToken(AlloyANTLR4GrammarParser.LPARENTHESIS, 0); }
		public TerminalNode NUMBER() { return getToken(AlloyANTLR4GrammarParser.NUMBER, 0); }
		public TerminalNode RCRLBRACKET() { return getToken(AlloyANTLR4GrammarParser.RCRLBRACKET, 0); }
		public TerminalNode INT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.INT_KEYWORD, 0); }
		public TerminalNode MINUS() { return getToken(AlloyANTLR4GrammarParser.MINUS, 0); }
		public TerminalNode IDEN_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.IDEN_KEYWORD, 0); }
		public TerminalNode AT() { return getToken(AlloyANTLR4GrammarParser.AT, 0); }
		public ExprTContext exprT() {
			return getRuleContext(ExprTContext.class,0);
		}
		public QuantContext quant() {
			return getRuleContext(QuantContext.class,0);
		}
		public TerminalNode COMMA(int i) {
			return getToken(AlloyANTLR4GrammarParser.COMMA, i);
		}
		public TerminalNode RPARENTHESIS() { return getToken(AlloyANTLR4GrammarParser.RPARENTHESIS, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public TerminalNode NONE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.NONE_KEYWORD, 0); }
		public TerminalNode LET_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.LET_KEYWORD, 0); }
		public List<TerminalNode> COMMA() { return getTokens(AlloyANTLR4GrammarParser.COMMA); }
		public List<LetDeclContext> letDecl() {
			return getRuleContexts(LetDeclContext.class);
		}
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public ExprHContext exprH() {
			return getRuleContext(ExprHContext.class,0);
		}
		public ExprHContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exprH; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterExprH(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitExprH(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitExprH(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExprHContext exprH() throws RecognitionException {
		ExprHContext _localctx = new ExprHContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_exprH);
		int _la;
		try {
			setState(372);
			switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(302); match(LCRLBRACKET);
				setState(303); decl();
				setState(308);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(304); match(COMMA);
					setState(305); decl();
					}
					}
					setState(310);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(311); blockOrBar();
				setState(312); match(RCRLBRACKET);
				setState(313); exprT();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(315); block();
				setState(316); exprT();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(319);
				_la = _input.LA(1);
				if (_la==AT) {
					{
					setState(318); match(AT);
					}
				}

				setState(321); name();
				setState(322); exprT();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(324); match(LPARENTHESIS);
				setState(325); exprH();
				setState(326); match(RPARENTHESIS);
				setState(327); exprT();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(329); match(SEQINT_KEYWORD);
				setState(330); exprT();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(331); match(INT_KEYWORD);
				setState(332); exprT();
				}
				break;

			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(333); match(UNIV_KEYWORD);
				setState(334); exprT();
				}
				break;

			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(335); match(IDEN_KEYWORD);
				setState(336); exprT();
				}
				break;

			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(337); match(NONE_KEYWORD);
				setState(338); exprT();
				}
				break;

			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(339); match(MINUS);
				setState(340); match(NUMBER);
				setState(341); exprT();
				}
				break;

			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(342); match(NUMBER);
				setState(343); exprT();
				}
				break;

			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(344); match(LET_KEYWORD);
				setState(345); letDecl();
				setState(350);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(346); match(COMMA);
					setState(347); letDecl();
					}
					}
					setState(352);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(353); blockOrBar();
				setState(354); exprT();
				}
				break;

			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(356); quant();
				setState(357); decl();
				setState(362);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(358); match(COMMA);
					setState(359); decl();
					}
					}
					setState(364);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(365); blockOrBar();
				setState(366); exprT();
				}
				break;

			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(368); unOp();
				setState(369); exprH();
				setState(370); exprT();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExprTContext extends ParserRuleContext {
		public TerminalNode LSQRBRACKET() { return getToken(AlloyANTLR4GrammarParser.LSQRBRACKET, 0); }
		public TerminalNode RSQRBRACKET() { return getToken(AlloyANTLR4GrammarParser.RSQRBRACKET, 0); }
		public ArrowOpContext arrowOp() {
			return getRuleContext(ArrowOpContext.class,0);
		}
		public TerminalNode EXCLAMATION() { return getToken(AlloyANTLR4GrammarParser.EXCLAMATION, 0); }
		public TerminalNode NOT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.NOT_KEYWORD, 0); }
		public ExprTContext exprT() {
			return getRuleContext(ExprTContext.class,0);
		}
		public TerminalNode COMMA(int i) {
			return getToken(AlloyANTLR4GrammarParser.COMMA, i);
		}
		public TerminalNode ELSE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ELSE_KEYWORD, 0); }
		public ExprHContext exprH(int i) {
			return getRuleContext(ExprHContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(AlloyANTLR4GrammarParser.COMMA); }
		public CompareOpContext compareOp() {
			return getRuleContext(CompareOpContext.class,0);
		}
		public TerminalNode IMPLICATION_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.IMPLICATION_KEYWORD, 0); }
		public List<ExprHContext> exprH() {
			return getRuleContexts(ExprHContext.class);
		}
		public BinOpContext binOp() {
			return getRuleContext(BinOpContext.class,0);
		}
		public ExprTContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exprT; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterExprT(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitExprT(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitExprT(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExprTContext exprT() throws RecognitionException {
		ExprTContext _localctx = new ExprTContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_exprT);
		int _la;
		try {
			setState(410);
			switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(374); binOp();
				setState(375); exprH();
				setState(376); exprT();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(378); arrowOp();
				setState(379); exprH();
				setState(380); exprT();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(383);
				_la = _input.LA(1);
				if (_la==EXCLAMATION || _la==NOT_KEYWORD) {
					{
					setState(382);
					_la = _input.LA(1);
					if ( !(_la==EXCLAMATION || _la==NOT_KEYWORD) ) {
					_errHandler.recoverInline(this);
					}
					consume();
					}
				}

				setState(385); compareOp();
				setState(386); exprH();
				setState(387); exprT();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(390);
				_la = _input.LA(1);
				if (_la==IMPLICATION_KEYWORD) {
					{
					setState(389); match(IMPLICATION_KEYWORD);
					}
				}

				setState(392); exprH();
				setState(393); match(ELSE_KEYWORD);
				setState(394); exprH();
				setState(395); exprT();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(397); match(LSQRBRACKET);
				setState(398); exprH();
				setState(403);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(399); match(COMMA);
					setState(400); exprH();
					}
					}
					setState(405);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(406); match(RSQRBRACKET);
				setState(407); exprT();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DeclContext extends ParserRuleContext {
		public TerminalNode DISJ_KEYWORD(int i) {
			return getToken(AlloyANTLR4GrammarParser.DISJ_KEYWORD, i);
		}
		public List<TerminalNode> COMMA() { return getTokens(AlloyANTLR4GrammarParser.COMMA); }
		public NameContext name(int i) {
			return getRuleContext(NameContext.class,i);
		}
		public List<TerminalNode> DISJ_KEYWORD() { return getTokens(AlloyANTLR4GrammarParser.DISJ_KEYWORD); }
		public ExprHContext exprH() {
			return getRuleContext(ExprHContext.class,0);
		}
		public TerminalNode COLON() { return getToken(AlloyANTLR4GrammarParser.COLON, 0); }
		public TerminalNode COMMA(int i) {
			return getToken(AlloyANTLR4GrammarParser.COMMA, i);
		}
		public TerminalNode PRIVATE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.PRIVATE_KEYWORD, 0); }
		public List<NameContext> name() {
			return getRuleContexts(NameContext.class);
		}
		public DeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeclContext decl() throws RecognitionException {
		DeclContext _localctx = new DeclContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_decl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(413);
			_la = _input.LA(1);
			if (_la==PRIVATE_KEYWORD) {
				{
				setState(412); match(PRIVATE_KEYWORD);
				}
			}

			setState(416);
			_la = _input.LA(1);
			if (_la==DISJ_KEYWORD) {
				{
				setState(415); match(DISJ_KEYWORD);
				}
			}

			setState(418); name();
			setState(423);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(419); match(COMMA);
				setState(420); name();
				}
				}
				setState(425);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(426); match(COLON);
			setState(428);
			_la = _input.LA(1);
			if (_la==DISJ_KEYWORD) {
				{
				setState(427); match(DISJ_KEYWORD);
				}
			}

			setState(430); exprH();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LetDeclContext extends ParserRuleContext {
		public TerminalNode EQUALS() { return getToken(AlloyANTLR4GrammarParser.EQUALS, 0); }
		public ExprHContext exprH() {
			return getRuleContext(ExprHContext.class,0);
		}
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public LetDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_letDecl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterLetDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitLetDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitLetDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LetDeclContext letDecl() throws RecognitionException {
		LetDeclContext _localctx = new LetDeclContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_letDecl);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(432); name();
			setState(433); match(EQUALS);
			setState(434); exprH();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuantContext extends ParserRuleContext {
		public TerminalNode SOME_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SOME_KEYWORD, 0); }
		public TerminalNode NO_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.NO_KEYWORD, 0); }
		public TerminalNode LONE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.LONE_KEYWORD, 0); }
		public TerminalNode ONE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ONE_KEYWORD, 0); }
		public TerminalNode ALL_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ALL_KEYWORD, 0); }
		public TerminalNode SUM_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SUM_KEYWORD, 0); }
		public QuantContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_quant; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterQuant(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitQuant(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitQuant(this);
			else return visitor.visitChildren(this);
		}
	}

	public final QuantContext quant() throws RecognitionException {
		QuantContext _localctx = new QuantContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_quant);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(436);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD) | (1L << ALL_KEYWORD) | (1L << NO_KEYWORD) | (1L << SUM_KEYWORD))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BinOpContext extends ParserRuleContext {
		public TerminalNode DISJUNCTION_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.DISJUNCTION_KEYWORD, 0); }
		public TerminalNode R3_ARROWS_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.R3_ARROWS_KEYWORD, 0); }
		public TerminalNode AND_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.AND_KEYWORD, 0); }
		public TerminalNode RESTRICTION_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.RESTRICTION_KEYWORD, 0); }
		public TerminalNode ET() { return getToken(AlloyANTLR4GrammarParser.ET, 0); }
		public TerminalNode BI_IMPLIC_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.BI_IMPLIC_KEYWORD, 0); }
		public TerminalNode MINUS() { return getToken(AlloyANTLR4GrammarParser.MINUS, 0); }
		public TerminalNode R2_ARROWS_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.R2_ARROWS_KEYWORD, 0); }
		public TerminalNode OR_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.OR_KEYWORD, 0); }
		public TerminalNode IFF_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.IFF_KEYWORD, 0); }
		public TerminalNode OVERRIDE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.OVERRIDE_KEYWORD, 0); }
		public TerminalNode IMPLICATION_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.IMPLICATION_KEYWORD, 0); }
		public TerminalNode PLUS() { return getToken(AlloyANTLR4GrammarParser.PLUS, 0); }
		public TerminalNode CONJUNCTION_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.CONJUNCTION_KEYWORD, 0); }
		public TerminalNode L2_ARROWS_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.L2_ARROWS_KEYWORD, 0); }
		public TerminalNode PERIOD() { return getToken(AlloyANTLR4GrammarParser.PERIOD, 0); }
		public BinOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_binOp; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterBinOp(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitBinOp(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitBinOp(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BinOpContext binOp() throws RecognitionException {
		BinOpContext _localctx = new BinOpContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_binOp);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(438);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << PERIOD) | (1L << ET) | (1L << IMPLICATION_KEYWORD) | (1L << AND_KEYWORD) | (1L << CONJUNCTION_KEYWORD) | (1L << OR_KEYWORD))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (DISJUNCTION_KEYWORD - 64)) | (1L << (IFF_KEYWORD - 64)) | (1L << (BI_IMPLIC_KEYWORD - 64)) | (1L << (OVERRIDE_KEYWORD - 64)) | (1L << (RESTRICTION_KEYWORD - 64)) | (1L << (R2_ARROWS_KEYWORD - 64)) | (1L << (R3_ARROWS_KEYWORD - 64)) | (1L << (L2_ARROWS_KEYWORD - 64)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrowOpContext extends ParserRuleContext {
		public TerminalNode LONE_KEYWORD(int i) {
			return getToken(AlloyANTLR4GrammarParser.LONE_KEYWORD, i);
		}
		public List<TerminalNode> SOME_KEYWORD() { return getTokens(AlloyANTLR4GrammarParser.SOME_KEYWORD); }
		public List<TerminalNode> LONE_KEYWORD() { return getTokens(AlloyANTLR4GrammarParser.LONE_KEYWORD); }
		public List<TerminalNode> ONE_KEYWORD() { return getTokens(AlloyANTLR4GrammarParser.ONE_KEYWORD); }
		public TerminalNode RARROW_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.RARROW_KEYWORD, 0); }
		public TerminalNode SET_KEYWORD(int i) {
			return getToken(AlloyANTLR4GrammarParser.SET_KEYWORD, i);
		}
		public TerminalNode ONE_KEYWORD(int i) {
			return getToken(AlloyANTLR4GrammarParser.ONE_KEYWORD, i);
		}
		public List<TerminalNode> SET_KEYWORD() { return getTokens(AlloyANTLR4GrammarParser.SET_KEYWORD); }
		public TerminalNode SOME_KEYWORD(int i) {
			return getToken(AlloyANTLR4GrammarParser.SOME_KEYWORD, i);
		}
		public ArrowOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrowOp; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterArrowOp(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitArrowOp(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitArrowOp(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArrowOpContext arrowOp() throws RecognitionException {
		ArrowOpContext _localctx = new ArrowOpContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_arrowOp);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(441);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD) | (1L << SET_KEYWORD))) != 0)) {
				{
				setState(440);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD) | (1L << SET_KEYWORD))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				}
			}

			setState(443); match(RARROW_KEYWORD);
			setState(445);
			switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
			case 1:
				{
				setState(444);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD) | (1L << SET_KEYWORD))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CompareOpContext extends ParserRuleContext {
		public TerminalNode LT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.LT_KEYWORD, 0); }
		public TerminalNode GT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.GT_KEYWORD, 0); }
		public TerminalNode EQUALS() { return getToken(AlloyANTLR4GrammarParser.EQUALS, 0); }
		public TerminalNode ELT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ELT_KEYWORD, 0); }
		public TerminalNode IN_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.IN_KEYWORD, 0); }
		public TerminalNode GET_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.GET_KEYWORD, 0); }
		public CompareOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compareOp; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterCompareOp(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitCompareOp(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitCompareOp(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CompareOpContext compareOp() throws RecognitionException {
		CompareOpContext _localctx = new CompareOpContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_compareOp);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(447);
			_la = _input.LA(1);
			if ( !(_la==EQUALS || _la==IN_KEYWORD || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (GT_KEYWORD - 73)) | (1L << (GET_KEYWORD - 73)) | (1L << (LT_KEYWORD - 73)) | (1L << (ELT_KEYWORD - 73)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnOpContext extends ParserRuleContext {
		public TerminalNode SEQ_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SEQ_KEYWORD, 0); }
		public TerminalNode SOME_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SOME_KEYWORD, 0); }
		public TerminalNode NO_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.NO_KEYWORD, 0); }
		public TerminalNode TILDE() { return getToken(AlloyANTLR4GrammarParser.TILDE, 0); }
		public TerminalNode LONE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.LONE_KEYWORD, 0); }
		public TerminalNode ONE_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.ONE_KEYWORD, 0); }
		public TerminalNode ASTERIX() { return getToken(AlloyANTLR4GrammarParser.ASTERIX, 0); }
		public TerminalNode EXCLAMATION() { return getToken(AlloyANTLR4GrammarParser.EXCLAMATION, 0); }
		public TerminalNode NOT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.NOT_KEYWORD, 0); }
		public TerminalNode CARET() { return getToken(AlloyANTLR4GrammarParser.CARET, 0); }
		public TerminalNode HASH() { return getToken(AlloyANTLR4GrammarParser.HASH, 0); }
		public TerminalNode SET_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SET_KEYWORD, 0); }
		public UnOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unOp; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterUnOp(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitUnOp(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitUnOp(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnOpContext unOp() throws RecognitionException {
		UnOpContext _localctx = new UnOpContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_unOp);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(449);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXCLAMATION) | (1L << HASH) | (1L << TILDE) | (1L << ASTERIX) | (1L << CARET) | (1L << SEQ_KEYWORD) | (1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD) | (1L << NOT_KEYWORD) | (1L << NO_KEYWORD) | (1L << SET_KEYWORD))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlockContext extends ParserRuleContext {
		public TerminalNode LCRLBRACKET() { return getToken(AlloyANTLR4GrammarParser.LCRLBRACKET, 0); }
		public ExprHContext exprH(int i) {
			return getRuleContext(ExprHContext.class,i);
		}
		public TerminalNode RCRLBRACKET() { return getToken(AlloyANTLR4GrammarParser.RCRLBRACKET, 0); }
		public List<ExprHContext> exprH() {
			return getRuleContexts(ExprHContext.class);
		}
		public BlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_block; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterBlock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitBlock(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitBlock(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockContext block() throws RecognitionException {
		BlockContext _localctx = new BlockContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(451); match(LCRLBRACKET);
			setState(455);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << NUMBER) | (1L << MINUS) | (1L << LCRLBRACKET) | (1L << LPARENTHESIS) | (1L << AT) | (1L << EXCLAMATION) | (1L << HASH) | (1L << TILDE) | (1L << ASTERIX) | (1L << CARET) | (1L << THIS_KEYWORD) | (1L << UNIV_KEYWORD) | (1L << INT_KEYWORD) | (1L << SEQINT_KEYWORD) | (1L << SEQ_KEYWORD) | (1L << LONE_KEYWORD) | (1L << ONE_KEYWORD) | (1L << SOME_KEYWORD) | (1L << NONE_KEYWORD) | (1L << IDEN_KEYWORD) | (1L << NOT_KEYWORD) | (1L << LET_KEYWORD) | (1L << ALL_KEYWORD) | (1L << NO_KEYWORD) | (1L << SET_KEYWORD) | (1L << SUM_KEYWORD))) != 0)) {
				{
				{
				setState(452); exprH();
				}
				}
				setState(457);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(458); match(RCRLBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlockOrBarContext extends ParserRuleContext {
		public TerminalNode BAR() { return getToken(AlloyANTLR4GrammarParser.BAR, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public ExprHContext exprH() {
			return getRuleContext(ExprHContext.class,0);
		}
		public BlockOrBarContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blockOrBar; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterBlockOrBar(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitBlockOrBar(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitBlockOrBar(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockOrBarContext blockOrBar() throws RecognitionException {
		BlockOrBarContext _localctx = new BlockOrBarContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_blockOrBar);
		try {
			setState(463);
			switch (_input.LA(1)) {
			case LCRLBRACKET:
				enterOuterAlt(_localctx, 1);
				{
				setState(460); block();
				}
				break;
			case BAR:
				enterOuterAlt(_localctx, 2);
				{
				setState(461); match(BAR);
				setState(462); exprH();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NameContext extends ParserRuleContext {
		public TerminalNode SLASH(int i) {
			return getToken(AlloyANTLR4GrammarParser.SLASH, i);
		}
		public TerminalNode NAME(int i) {
			return getToken(AlloyANTLR4GrammarParser.NAME, i);
		}
		public TerminalNode THIS_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.THIS_KEYWORD, 0); }
		public List<TerminalNode> NAME() { return getTokens(AlloyANTLR4GrammarParser.NAME); }
		public List<TerminalNode> SLASH() { return getTokens(AlloyANTLR4GrammarParser.SLASH); }
		public NameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitName(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NameContext name() throws RecognitionException {
		NameContext _localctx = new NameContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_name);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(465);
			_la = _input.LA(1);
			if ( !(_la==NAME || _la==THIS_KEYWORD) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			setState(470);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SLASH) {
				{
				{
				setState(466); match(SLASH);
				setState(467); match(NAME);
				}
				}
				setState(472);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RefContext extends ParserRuleContext {
		public TerminalNode UNIV_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.UNIV_KEYWORD, 0); }
		public TerminalNode SEQINT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.SEQINT_KEYWORD, 0); }
		public TerminalNode INT_KEYWORD() { return getToken(AlloyANTLR4GrammarParser.INT_KEYWORD, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public RefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ref; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).enterRef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AlloyANTLR4GrammarListener ) ((AlloyANTLR4GrammarListener)listener).exitRef(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AlloyANTLR4GrammarVisitor ) return ((AlloyANTLR4GrammarVisitor<? extends T>)visitor).visitRef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RefContext ref() throws RecognitionException {
		RefContext _localctx = new RefContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_ref);
		int _la;
		try {
			setState(475);
			switch (_input.LA(1)) {
			case NAME:
			case THIS_KEYWORD:
				enterOuterAlt(_localctx, 1);
				{
				setState(473); name();
				}
				break;
			case UNIV_KEYWORD:
			case INT_KEYWORD:
			case SEQINT_KEYWORD:
				enterOuterAlt(_localctx, 2);
				{
				setState(474);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << UNIV_KEYWORD) | (1L << INT_KEYWORD) | (1L << SEQINT_KEYWORD))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3N\u01e0\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\3\2\5\2:\n\2\3\2\7\2=\n\2\f\2\16\2@\13"+
		"\2\3\2\7\2C\n\2\f\2\16\2F\13\2\3\2\3\2\3\3\3\3\3\3\3\3\5\3N\n\3\3\3\3"+
		"\3\3\3\5\3S\n\3\3\3\7\3V\n\3\f\3\16\3Y\13\3\3\3\3\3\5\3]\n\3\3\4\5\4`"+
		"\n\4\3\4\3\4\3\4\3\4\3\4\3\4\7\4h\n\4\f\4\16\4k\13\4\3\4\3\4\5\4o\n\4"+
		"\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\5\5z\n\5\3\6\3\6\5\6~\n\6\3\6\3\6"+
		"\3\7\3\7\5\7\u0084\n\7\3\7\3\7\3\b\5\b\u0089\n\b\3\b\3\b\3\b\3\b\5\b\u008f"+
		"\n\b\3\b\3\b\3\b\7\b\u0094\n\b\f\b\16\b\u0097\13\b\3\b\3\b\3\b\3\b\7\b"+
		"\u009d\n\b\f\b\16\b\u00a0\13\b\3\b\3\b\5\b\u00a4\n\b\3\b\3\b\3\b\3\b\5"+
		"\b\u00aa\n\b\3\b\3\b\3\b\3\b\5\b\u00b0\n\b\3\b\3\b\3\b\7\b\u00b5\n\b\f"+
		"\b\16\b\u00b8\13\b\3\b\3\b\3\b\3\b\7\b\u00be\n\b\f\b\16\b\u00c1\13\b\3"+
		"\b\3\b\5\b\u00c5\n\b\3\b\3\b\5\b\u00c9\n\b\3\t\3\t\3\t\5\t\u00ce\n\t\3"+
		"\t\5\t\u00d1\n\t\3\t\3\t\5\t\u00d5\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n"+
		"\7\n\u00df\n\n\f\n\16\n\u00e2\13\n\5\n\u00e4\n\n\3\n\3\n\3\n\7\n\u00e9"+
		"\n\n\f\n\16\n\u00ec\13\n\5\n\u00ee\n\n\3\13\5\13\u00f1\n\13\3\13\3\13"+
		"\3\13\5\13\u00f6\n\13\3\f\7\f\u00f9\n\f\f\f\16\f\u00fc\13\f\3\f\3\f\3"+
		"\f\3\f\7\f\u0102\n\f\f\f\16\f\u0105\13\f\3\f\5\f\u0108\n\f\3\f\3\f\7\f"+
		"\u010c\n\f\f\f\16\f\u010f\13\f\3\f\3\f\5\f\u0113\n\f\3\r\3\r\3\r\3\r\3"+
		"\r\3\r\7\r\u011b\n\r\f\r\16\r\u011e\13\r\3\r\3\r\3\16\3\16\3\17\3\17\3"+
		"\17\3\17\3\17\3\17\7\17\u012a\n\17\f\17\16\17\u012d\13\17\5\17\u012f\n"+
		"\17\3\20\3\20\3\20\3\20\7\20\u0135\n\20\f\20\16\20\u0138\13\20\3\20\3"+
		"\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u0142\n\20\3\20\3\20\3\20\3\20"+
		"\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
		"\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u015f\n\20\f\20\16"+
		"\20\u0162\13\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u016b\n\20\f\20"+
		"\16\20\u016e\13\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u0177\n\20"+
		"\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u0182\n\21\3\21\3\21"+
		"\3\21\3\21\3\21\5\21\u0189\n\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
		"\3\21\7\21\u0194\n\21\f\21\16\21\u0197\13\21\3\21\3\21\3\21\3\21\5\21"+
		"\u019d\n\21\3\22\5\22\u01a0\n\22\3\22\5\22\u01a3\n\22\3\22\3\22\3\22\7"+
		"\22\u01a8\n\22\f\22\16\22\u01ab\13\22\3\22\3\22\5\22\u01af\n\22\3\22\3"+
		"\22\3\23\3\23\3\23\3\23\3\24\3\24\3\25\3\25\3\26\5\26\u01bc\n\26\3\26"+
		"\3\26\5\26\u01c0\n\26\3\27\3\27\3\30\3\30\3\31\3\31\7\31\u01c8\n\31\f"+
		"\31\16\31\u01cb\13\31\3\31\3\31\3\32\3\32\3\32\5\32\u01d2\n\32\3\33\3"+
		"\33\3\33\7\33\u01d7\n\33\f\33\16\33\u01da\13\33\3\34\3\34\5\34\u01de\n"+
		"\34\3\34\2\35\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64"+
		"\66\2\r\3\2()\3\2!\"\4\2\35\35.\61\4\2\24\2488\5\2/\61;<>>\7\2\6\6\b\t"+
		"\23\23\66\66?I\4\2/\61==\5\2\7\7\63\63KN\7\2\24\30##/\6188<=\4\2\3\3\34"+
		"\34\3\2 \"\u0218\29\3\2\2\2\4I\3\2\2\2\6_\3\2\2\2\by\3\2\2\2\n{\3\2\2"+
		"\2\f\u0081\3\2\2\2\16\u00c8\3\2\2\2\20\u00cd\3\2\2\2\22\u00d8\3\2\2\2"+
		"\24\u00f0\3\2\2\2\26\u00fa\3\2\2\2\30\u0114\3\2\2\2\32\u0121\3\2\2\2\34"+
		"\u012e\3\2\2\2\36\u0176\3\2\2\2 \u019c\3\2\2\2\"\u019f\3\2\2\2$\u01b2"+
		"\3\2\2\2&\u01b6\3\2\2\2(\u01b8\3\2\2\2*\u01bb\3\2\2\2,\u01c1\3\2\2\2."+
		"\u01c3\3\2\2\2\60\u01c5\3\2\2\2\62\u01d1\3\2\2\2\64\u01d3\3\2\2\2\66\u01dd"+
		"\3\2\2\28:\5\4\3\298\3\2\2\29:\3\2\2\2:>\3\2\2\2;=\5\6\4\2<;\3\2\2\2="+
		"@\3\2\2\2><\3\2\2\2>?\3\2\2\2?D\3\2\2\2@>\3\2\2\2AC\5\b\5\2BA\3\2\2\2"+
		"CF\3\2\2\2DB\3\2\2\2DE\3\2\2\2EG\3\2\2\2FD\3\2\2\2GH\7\2\2\3H\3\3\2\2"+
		"\2IJ\7\33\2\2J\\\5\64\33\2KM\7\f\2\2LN\7\32\2\2ML\3\2\2\2MN\3\2\2\2NO"+
		"\3\2\2\2OW\5\64\33\2PR\7\5\2\2QS\7\32\2\2RQ\3\2\2\2RS\3\2\2\2ST\3\2\2"+
		"\2TV\5\64\33\2UP\3\2\2\2VY\3\2\2\2WU\3\2\2\2WX\3\2\2\2XZ\3\2\2\2YW\3\2"+
		"\2\2Z[\7\r\2\2[]\3\2\2\2\\K\3\2\2\2\\]\3\2\2\2]\5\3\2\2\2^`\7\35\2\2_"+
		"^\3\2\2\2_`\3\2\2\2`a\3\2\2\2ab\7\36\2\2bn\5\64\33\2cd\7\f\2\2di\5\66"+
		"\34\2ef\7\5\2\2fh\5\66\34\2ge\3\2\2\2hk\3\2\2\2ig\3\2\2\2ij\3\2\2\2jl"+
		"\3\2\2\2ki\3\2\2\2lm\7\r\2\2mo\3\2\2\2nc\3\2\2\2no\3\2\2\2op\3\2\2\2p"+
		"q\7\37\2\2qr\5\64\33\2r\7\3\2\2\2sz\5\n\6\2tz\5\f\7\2uz\5\16\b\2vz\5\20"+
		"\t\2wz\5\30\r\2xz\5\26\f\2ys\3\2\2\2yt\3\2\2\2yu\3\2\2\2yv\3\2\2\2yw\3"+
		"\2\2\2yx\3\2\2\2z\t\3\2\2\2{}\7$\2\2|~\5\64\33\2}|\3\2\2\2}~\3\2\2\2~"+
		"\177\3\2\2\2\177\u0080\5\60\31\2\u0080\13\3\2\2\2\u0081\u0083\7%\2\2\u0082"+
		"\u0084\5\64\33\2\u0083\u0082\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0085\3"+
		"\2\2\2\u0085\u0086\5\60\31\2\u0086\r\3\2\2\2\u0087\u0089\7\35\2\2\u0088"+
		"\u0087\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008e\7&"+
		"\2\2\u008b\u008c\5\66\34\2\u008c\u008d\7\t\2\2\u008d\u008f\3\2\2\2\u008e"+
		"\u008b\3\2\2\2\u008e\u008f\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u00a3\5\64"+
		"\33\2\u0091\u0095\7\20\2\2\u0092\u0094\5\"\22\2\u0093\u0092\3\2\2\2\u0094"+
		"\u0097\3\2\2\2\u0095\u0093\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0098\3\2"+
		"\2\2\u0097\u0095\3\2\2\2\u0098\u0099\7\21\2\2\u0099\u00a4\7\n\2\2\u009a"+
		"\u009e\7\f\2\2\u009b\u009d\5\"\22\2\u009c\u009b\3\2\2\2\u009d\u00a0\3"+
		"\2\2\2\u009e\u009c\3\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a1\3\2\2\2\u00a0"+
		"\u009e\3\2\2\2\u00a1\u00a2\7\r\2\2\u00a2\u00a4\7\n\2\2\u00a3\u0091\3\2"+
		"\2\2\u00a3\u009a\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5"+
		"\u00a6\5\36\20\2\u00a6\u00a7\5\60\31\2\u00a7\u00c9\3\2\2\2\u00a8\u00aa"+
		"\7\35\2\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2"+
		"\u00ab\u00af\7\'\2\2\u00ac\u00ad\5\66\34\2\u00ad\u00ae\7\t\2\2\u00ae\u00b0"+
		"\3\2\2\2\u00af\u00ac\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1"+
		"\u00c4\5\64\33\2\u00b2\u00b6\7\20\2\2\u00b3\u00b5\5\"\22\2\u00b4\u00b3"+
		"\3\2\2\2\u00b5\u00b8\3\2\2\2\u00b6\u00b4\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7"+
		"\u00b9\3\2\2\2\u00b8\u00b6\3\2\2\2\u00b9\u00ba\7\21\2\2\u00ba\u00c5\7"+
		"\n\2\2\u00bb\u00bf\7\f\2\2\u00bc\u00be\5\"\22\2\u00bd\u00bc\3\2\2\2\u00be"+
		"\u00c1\3\2\2\2\u00bf\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c2\3\2"+
		"\2\2\u00c1\u00bf\3\2\2\2\u00c2\u00c3\7\r\2\2\u00c3\u00c5\7\n\2\2\u00c4"+
		"\u00b2\3\2\2\2\u00c4\u00bb\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c6\3\2"+
		"\2\2\u00c6\u00c7\5\60\31\2\u00c7\u00c9\3\2\2\2\u00c8\u0088\3\2\2\2\u00c8"+
		"\u00a9\3\2\2\2\u00c9\17\3\2\2\2\u00ca\u00cb\5\64\33\2\u00cb\u00cc\7\n"+
		"\2\2\u00cc\u00ce\3\2\2\2\u00cd\u00ca\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce"+
		"\u00d0\3\2\2\2\u00cf\u00d1\t\2\2\2\u00d0\u00cf\3\2\2\2\u00d0\u00d1\3\2"+
		"\2\2\u00d1\u00d4\3\2\2\2\u00d2\u00d5\5\64\33\2\u00d3\u00d5\5\60\31\2\u00d4"+
		"\u00d2\3\2\2\2\u00d4\u00d3\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00d6\3\2"+
		"\2\2\u00d6\u00d7\5\22\n\2\u00d7\21\3\2\2\2\u00d8\u00ed\7*\2\2\u00d9\u00e3"+
		"\7\4\2\2\u00da\u00db\7+\2\2\u00db\u00e0\5\24\13\2\u00dc\u00dd\7\5\2\2"+
		"\u00dd\u00df\5\24\13\2\u00de\u00dc\3\2\2\2\u00df\u00e2\3\2\2\2\u00e0\u00de"+
		"\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1\u00e4\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3"+
		"\u00da\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u00ee\3\2\2\2\u00e5\u00ea\5\24"+
		"\13\2\u00e6\u00e7\7\5\2\2\u00e7\u00e9\5\24\13\2\u00e8\u00e6\3\2\2\2\u00e9"+
		"\u00ec\3\2\2\2\u00ea\u00e8\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ee\3\2"+
		"\2\2\u00ec\u00ea\3\2\2\2\u00ed\u00d9\3\2\2\2\u00ed\u00e5\3\2\2\2\u00ee"+
		"\23\3\2\2\2\u00ef\u00f1\7\32\2\2\u00f0\u00ef\3\2\2\2\u00f0\u00f1\3\2\2"+
		"\2\u00f1\u00f2\3\2\2\2\u00f2\u00f5\7\4\2\2\u00f3\u00f6\5\64\33\2\u00f4"+
		"\u00f6\t\3\2\2\u00f5\u00f3\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f5\u00f6\3\2"+
		"\2\2\u00f6\25\3\2\2\2\u00f7\u00f9\5\32\16\2\u00f8\u00f7\3\2\2\2\u00f9"+
		"\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00fd\3\2"+
		"\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\7,\2\2\u00fe\u0103\5\64\33\2\u00ff"+
		"\u0100\7\5\2\2\u0100\u0102\5\64\33\2\u0101\u00ff\3\2\2\2\u0102\u0105\3"+
		"\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0107\3\2\2\2\u0105"+
		"\u0103\3\2\2\2\u0106\u0108\5\34\17\2\u0107\u0106\3\2\2\2\u0107\u0108\3"+
		"\2\2\2\u0108\u0109\3\2\2\2\u0109\u010d\7\16\2\2\u010a\u010c\5\"\22\2\u010b"+
		"\u010a\3\2\2\2\u010c\u010f\3\2\2\2\u010d\u010b\3\2\2\2\u010d\u010e\3\2"+
		"\2\2\u010e\u0110\3\2\2\2\u010f\u010d\3\2\2\2\u0110\u0112\7\17\2\2\u0111"+
		"\u0113\5\60\31\2\u0112\u0111\3\2\2\2\u0112\u0113\3\2\2\2\u0113\27\3\2"+
		"\2\2\u0114\u0115\7-\2\2\u0115\u0116\5\64\33\2\u0116\u0117\7\16\2\2\u0117"+
		"\u011c\5\64\33\2\u0118\u0119\7\5\2\2\u0119\u011b\5\64\33\2\u011a\u0118"+
		"\3\2\2\2\u011b\u011e\3\2\2\2\u011c\u011a\3\2\2\2\u011c\u011d\3\2\2\2\u011d"+
		"\u011f\3\2\2\2\u011e\u011c\3\2\2\2\u011f\u0120\7\17\2\2\u0120\31\3\2\2"+
		"\2\u0121\u0122\t\4\2\2\u0122\33\3\2\2\2\u0123\u0124\7\62\2\2\u0124\u012f"+
		"\5\66\34\2\u0125\u0126\7\63\2\2\u0126\u012b\5\66\34\2\u0127\u0128\7\6"+
		"\2\2\u0128\u012a\5\66\34\2\u0129\u0127\3\2\2\2\u012a\u012d\3\2\2\2\u012b"+
		"\u0129\3\2\2\2\u012b\u012c\3\2\2\2\u012c\u012f\3\2\2\2\u012d\u012b\3\2"+
		"\2\2\u012e\u0123\3\2\2\2\u012e\u0125\3\2\2\2\u012f\35\3\2\2\2\u0130\u0131"+
		"\7\16\2\2\u0131\u0136\5\"\22\2\u0132\u0133\7\5\2\2\u0133\u0135\5\"\22"+
		"\2\u0134\u0132\3\2\2\2\u0135\u0138\3\2\2\2\u0136\u0134\3\2\2\2\u0136\u0137"+
		"\3\2\2\2\u0137\u0139\3\2\2\2\u0138\u0136\3\2\2\2\u0139\u013a\5\62\32\2"+
		"\u013a\u013b\7\17\2\2\u013b\u013c\5 \21\2\u013c\u0177\3\2\2\2\u013d\u013e"+
		"\5\60\31\2\u013e\u013f\5 \21\2\u013f\u0177\3\2\2\2\u0140\u0142\7\22\2"+
		"\2\u0141\u0140\3\2\2\2\u0141\u0142\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0144"+
		"\5\64\33\2\u0144\u0145\5 \21\2\u0145\u0177\3\2\2\2\u0146\u0147\7\20\2"+
		"\2\u0147\u0148\5\36\20\2\u0148\u0149\7\21\2\2\u0149\u014a\5 \21\2\u014a"+
		"\u0177\3\2\2\2\u014b\u014c\7\"\2\2\u014c\u0177\5 \21\2\u014d\u014e\7!"+
		"\2\2\u014e\u0177\5 \21\2\u014f\u0150\7 \2\2\u0150\u0177\5 \21\2\u0151"+
		"\u0152\7\65\2\2\u0152\u0177\5 \21\2\u0153\u0154\7\64\2\2\u0154\u0177\5"+
		" \21\2\u0155\u0156\7\b\2\2\u0156\u0157\7\4\2\2\u0157\u0177\5 \21\2\u0158"+
		"\u0159\7\4\2\2\u0159\u0177\5 \21\2\u015a\u015b\79\2\2\u015b\u0160\5$\23"+
		"\2\u015c\u015d\7\5\2\2\u015d\u015f\5$\23\2\u015e\u015c\3\2\2\2\u015f\u0162"+
		"\3\2\2\2\u0160\u015e\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0163\3\2\2\2\u0162"+
		"\u0160\3\2\2\2\u0163\u0164\5\62\32\2\u0164\u0165\5 \21\2\u0165\u0177\3"+
		"\2\2\2\u0166\u0167\5&\24\2\u0167\u016c\5\"\22\2\u0168\u0169\7\5\2\2\u0169"+
		"\u016b\5\"\22\2\u016a\u0168\3\2\2\2\u016b\u016e\3\2\2\2\u016c\u016a\3"+
		"\2\2\2\u016c\u016d\3\2\2\2\u016d\u016f\3\2\2\2\u016e\u016c\3\2\2\2\u016f"+
		"\u0170\5\62\32\2\u0170\u0171\5 \21\2\u0171\u0177\3\2\2\2\u0172\u0173\5"+
		".\30\2\u0173\u0174\5\36\20\2\u0174\u0175\5 \21\2\u0175\u0177\3\2\2\2\u0176"+
		"\u0130\3\2\2\2\u0176\u013d\3\2\2\2\u0176\u0141\3\2\2\2\u0176\u0146\3\2"+
		"\2\2\u0176\u014b\3\2\2\2\u0176\u014d\3\2\2\2\u0176\u014f\3\2\2\2\u0176"+
		"\u0151\3\2\2\2\u0176\u0153\3\2\2\2\u0176\u0155\3\2\2\2\u0176\u0158\3\2"+
		"\2\2\u0176\u015a\3\2\2\2\u0176\u0166\3\2\2\2\u0176\u0172\3\2\2\2\u0177"+
		"\37\3\2\2\2\u0178\u0179\5(\25\2\u0179\u017a\5\36\20\2\u017a\u017b\5 \21"+
		"\2\u017b\u019d\3\2\2\2\u017c\u017d\5*\26\2\u017d\u017e\5\36\20\2\u017e"+
		"\u017f\5 \21\2\u017f\u019d\3\2\2\2\u0180\u0182\t\5\2\2\u0181\u0180\3\2"+
		"\2\2\u0181\u0182\3\2\2\2\u0182\u0183\3\2\2\2\u0183\u0184\5,\27\2\u0184"+
		"\u0185\5\36\20\2\u0185\u0186\5 \21\2\u0186\u019d\3\2\2\2\u0187\u0189\7"+
		"\66\2\2\u0188\u0187\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u018a\3\2\2\2\u018a"+
		"\u018b\5\36\20\2\u018b\u018c\7\67\2\2\u018c\u018d\5\36\20\2\u018d\u018e"+
		"\5 \21\2\u018e\u019d\3\2\2\2\u018f\u0190\7\f\2\2\u0190\u0195\5\36\20\2"+
		"\u0191\u0192\7\5\2\2\u0192\u0194\5\36\20\2\u0193\u0191\3\2\2\2\u0194\u0197"+
		"\3\2\2\2\u0195\u0193\3\2\2\2\u0195\u0196\3\2\2\2\u0196\u0198\3\2\2\2\u0197"+
		"\u0195\3\2\2\2\u0198\u0199\7\r\2\2\u0199\u019a\5 \21\2\u019a\u019d\3\2"+
		"\2\2\u019b\u019d\3\2\2\2\u019c\u0178\3\2\2\2\u019c\u017c\3\2\2\2\u019c"+
		"\u0181\3\2\2\2\u019c\u0188\3\2\2\2\u019c\u018f\3\2\2\2\u019c\u019b\3\2"+
		"\2\2\u019d!\3\2\2\2\u019e\u01a0\7\35\2\2\u019f\u019e\3\2\2\2\u019f\u01a0"+
		"\3\2\2\2\u01a0\u01a2\3\2\2\2\u01a1\u01a3\7:\2\2\u01a2\u01a1\3\2\2\2\u01a2"+
		"\u01a3\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4\u01a9\5\64\33\2\u01a5\u01a6\7"+
		"\5\2\2\u01a6\u01a8\5\64\33\2\u01a7\u01a5\3\2\2\2\u01a8\u01ab\3\2\2\2\u01a9"+
		"\u01a7\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ac\3\2\2\2\u01ab\u01a9\3\2"+
		"\2\2\u01ac\u01ae\7\n\2\2\u01ad\u01af\7:\2\2\u01ae\u01ad\3\2\2\2\u01ae"+
		"\u01af\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\5\36\20\2\u01b1#\3\2\2"+
		"\2\u01b2\u01b3\5\64\33\2\u01b3\u01b4\7\7\2\2\u01b4\u01b5\5\36\20\2\u01b5"+
		"%\3\2\2\2\u01b6\u01b7\t\6\2\2\u01b7\'\3\2\2\2\u01b8\u01b9\t\7\2\2\u01b9"+
		")\3\2\2\2\u01ba\u01bc\t\b\2\2\u01bb\u01ba\3\2\2\2\u01bb\u01bc\3\2\2\2"+
		"\u01bc\u01bd\3\2\2\2\u01bd\u01bf\7J\2\2\u01be\u01c0\t\b\2\2\u01bf\u01be"+
		"\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0+\3\2\2\2\u01c1\u01c2\t\t\2\2\u01c2"+
		"-\3\2\2\2\u01c3\u01c4\t\n\2\2\u01c4/\3\2\2\2\u01c5\u01c9\7\16\2\2\u01c6"+
		"\u01c8\5\36\20\2\u01c7\u01c6\3\2\2\2\u01c8\u01cb\3\2\2\2\u01c9\u01c7\3"+
		"\2\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cc\3\2\2\2\u01cb\u01c9\3\2\2\2\u01cc"+
		"\u01cd\7\17\2\2\u01cd\61\3\2\2\2\u01ce\u01d2\5\60\31\2\u01cf\u01d0\7\31"+
		"\2\2\u01d0\u01d2\5\36\20\2\u01d1\u01ce\3\2\2\2\u01d1\u01cf\3\2\2\2\u01d2"+
		"\63\3\2\2\2\u01d3\u01d8\t\13\2\2\u01d4\u01d5\7\13\2\2\u01d5\u01d7\7\3"+
		"\2\2\u01d6\u01d4\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8"+
		"\u01d9\3\2\2\2\u01d9\65\3\2\2\2\u01da\u01d8\3\2\2\2\u01db\u01de\5\64\33"+
		"\2\u01dc\u01de\t\f\2\2\u01dd\u01db\3\2\2\2\u01dd\u01dc\3\2\2\2\u01de\67"+
		"\3\2\2\2>9>DMRW\\_iny}\u0083\u0088\u008e\u0095\u009e\u00a3\u00a9\u00af"+
		"\u00b6\u00bf\u00c4\u00c8\u00cd\u00d0\u00d4\u00e0\u00e3\u00ea\u00ed\u00f0"+
		"\u00f5\u00fa\u0103\u0107\u010d\u0112\u011c\u012b\u012e\u0136\u0141\u0160"+
		"\u016c\u0176\u0181\u0188\u0195\u019c\u019f\u01a2\u01a9\u01ae\u01bb\u01bf"+
		"\u01c9\u01d1\u01d8\u01dd";
	public static final ATN _ATN =
		ATNSimulator.deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}